<template>
  <view class="container">
    <!-- 使用 AdaptiveNavBar 组件 -->
    <AdaptiveNavBar 
      :showBack="true" 
      title="班期管理" 
      :showHome="false" 
      :showShadow="false" 
      text-color="#ffffff"
      :background-color="navBarBackgroundColor" 
    />

    <!-- 可滚动内容区域 -->
    <view class="content-area" :style="{ marginTop: $navbarUtil.getNavbarTotalHeightRpx() }">
    <scroll-view 
      class="scrollable-content" 
      scroll-y
      :enable-back-to-top="false"
      :scroll-with-animation="false"
      :bounces="false"
      :show-scrollbar="false"
    >
      <view class="calendar-container">
        <!-- 提示信息 - 仅对二类三类商家显示 -->
        <!-- <view v-if="isType2OrType3" class="tip-notice">
          <text class="tip-icon">ℹ️</text>
          <text class="tip-text">您只能从已选中的日期中进行选择或取消操作，其他日期不可选择</text>
        </view> -->

        <!-- 模式切换按钮 - 已隐藏，根据业务类型自动设置选择模式 -->
        <!-- 一类所有情况、二类目的地(3)与综合(2)：显示为"创建状态"（A模式） -->
        <!-- 二类组团业务(4)与三类：显示为"选择申请调用状态"（B模式） -->

        <!-- 自定义日历组件 -->
        <CustomCalendar
          :key="`calendar-${currentSelectMode}-${selectedDatesA.length}-${selectedDatesB.length}`"
          :show="true"
          :selectMode="currentSelectMode"
          :defaultDateA="selectedDatesA"
          :defaultDateB="selectedDatesB"
          :minDate="minDate"
          :maxDate="maxDate"
          :monthNum="7"
          colorA="#1677FF"
          colorB="#52c41a"
          :disabledDate="disabledDates"
          :showTitle="true"
          :showSubtitle="true"
          :pageInline="true"
          :readonly="isReadonlyMode"
          :businessType="businessType"
          :productType="productType"
          :isApplyCall="isApplyCall"
          :applicationDeadline="applicationDeadline"
          @dayClick="onDayClick"
          @change="onCalendarChange"
          @monthChange="onMonthChange"
        />
      </view>
    </scroll-view>
    </view>

    <!-- 固定在底部的区域 -->
    <view class="fixed-bottom">
      <button v-if="selectedDates.length > 0" class="confirm-btn" @tap="confirmSelect">确定</button>

      <!-- 滚动栏区域 -->
      <view class="scroll-container">
        <!-- 当前已选班期（用户标记-绿色） -->
        <view class="scroll-section">
          <view class="title-row">
            <text class="scroll-title">当前已选班期</text>
            <view class="expand-icon" @tap="toggleUserExpand" v-if="userButtonShow">
              <icon class="cuIcon-right" :class="{ fold: !showUserExpand }" type="" />
            </view>
          </view>

          <view v-if="!showUserExpand">
            <scroll-view class="scroll-view" scroll-x>
              <view class="scroll-item marked" v-for="item in formattedUserMarkedDates"
                :key="item.month + '-' + item.day">
                <text class="scroll-date">{{ item.month }}-{{ item.day }}</text>
                <text class="scroll-week">周{{ item.weekDay }}</text>
              </view>
            </scroll-view>
          </view>

          <view v-else class="expand-container">
            <view class="expand-row">
              <view class="expand-item marked" v-for="item in formattedUserMarkedDates"
                :key="item.month + '-' + item.day">
                <text class="expand-date">{{ item.month }}-{{ item.day }}</text>
                <text class="expand-week">周{{ item.weekDay }}</text>
              </view>
            </view>
          </view>
        </view>

        <!-- 不可改变班期（初始标记-蓝色） -->
        <view class="scroll-section">
          <view class="title-row">
            <text class="scroll-title">不可改变班期</text>
            <view class="expand-icon" @tap="toggleInitialExpand" v-if="initialButtonShow">
              <icon class="cuIcon-right" :class="{ fold: !showInitialExpand }" type="" />
            </view>
          </view>

          <view v-if="!showInitialExpand">
            <scroll-view class="scroll-view" scroll-x>
              <view class="scroll-item initial-marked" v-for="item in formattedInitialMarkedDates"
                :key="item.month + '-' + item.day">
                <text class="scroll-date">{{ item.month }}-{{ item.day }}</text>
                <text class="scroll-week">周{{ item.weekDay }}</text>
              </view>
            </scroll-view>
          </view>

          <view v-else class="expand-container">
            <view class="expand-row">
              <view class="expand-item initial-marked" v-for="item in formattedInitialMarkedDates"
                :key="item.month + '-' + item.day">
                <text class="expand-date">{{ item.month }}-{{ item.day }}</text>
                <text class="expand-week">周{{ item.weekDay }}</text>
              </view>
            </view>
          </view>
        </view>
      </view>
    </view>
  </view>
</template>

<script>
import CustomCalendar from '@/components/CustomCalendar.vue'
import AdaptiveNavBar from '@/components/AdaptiveNavBar.vue'

export default {
  components: {
    CustomCalendar,
    AdaptiveNavBar
  },
  data() {
    return {
      StatusBar: 0, // 适配顶部状态栏（系统状态栏高度）
      selectedDates: [], // 选中的日期数组（兼容旧代码）
      selectedDatesArray: [], // 用于Calendar组件的默认日期（兼容旧代码）
      selectedDatesA: [], // A状态选中的日期数组
      selectedDatesB: [], // B状态选中的日期数组
      currentSelectMode: 'A', // 当前选择模式：'A' 或 'B'
      initialMarkedDates: [], // 不可改变班期（蓝色）
      showUserExpand: false, // 用户标记展开状态
      showInitialExpand: false, // 初始标记展开状态
      userButtonShow: true, // 用户标记按钮显示状态
      initialButtonShow: true, // 初始标记按钮显示状态
      weekDays: ['日', '一', '二', '三', '四', '五', '六'],
      formattedUserMarkedDates: [],
      formattedInitialMarkedDates: [],
      id: -1,
      calendarWatcher: null, // 日历监听定时器
      businessType: 1, // 业务类型 (1: 一类商家, 2: 二类商家, 3: 三类商家)
      isApplyCall: false, // 是否为申请调用
      applicationDeadline: 15, // 申请截止天数
      productId: 0, // 产品ID
      productType: 0, // 产品类型 (1-泛营地接待, 2-综合研学业务, 3-目的地接待, 4-组团业务, 5-研学活动)
      allowedSelectDates: [], // 允许选择的日期列表
      minSelectedDates: [], // 最小选中日期（防止取消选中）
      periodList: [], // 班期列表（从外部传入）
      outerPeriodList: [], // 外层班期列表（用于二类组团业务）
      isReadonlyMode: false, // 是否只读模式（用户无法手动更改AB状态）
      allowEdit: false // 是否允许编辑（从合作申请管理页面进入时允许编辑）
    }
  },

  computed: {
    // 获取导航栏背景色（固定为 #1677FF）
    navBarBackgroundColor() {
      return '#1677FF';
    },
    minDate() {
      const today = new Date();
      const year = today.getFullYear();
      const month = String(today.getMonth() + 1).padStart(2, '0');
      const day = String(today.getDate()).padStart(2, '0');
      return `${year}-${month}-${day}`;
    },
    maxDate() {
      const today = new Date();
      // 创建一个新日期对象，避免修改原始日期
      const maxDate = new Date(today);
      maxDate.setMonth(maxDate.getMonth() + 6); // 6个月后
      const year = maxDate.getFullYear();
      const month = String(maxDate.getMonth() + 1).padStart(2, '0');
      const day = String(maxDate.getDate()).padStart(2, '0');
      return `${year}-${month}-${day}`;
    },
    // 判断是否为二类或三类商家
    isType2OrType3() {
      return (this.isApplyCall && this.businessType === 2) || this.businessType === 3;
    },
    // 禁用日期列表（用于二类组团业务和三类商家）
    disabledDates() {
      // 返回一个函数，用于判断日期是否应该被禁用
      return (date) => {
        // 将日期转换为 YYYY-MM-DD 格式
        const dateStr = `${date.year}-${String(date.month).padStart(2, '0')}-${String(date.date).padStart(2, '0')}`;
        
        // 如果允许编辑（从 periodCreate 或 cooperation 进入），仍然需要根据 applicationDeadline 判断
        // 但是，如果日期已经在班期列表中（A或B状态），应该允许操作（可以取消选中）
        if (this.allowEdit) {
          // 检查日期是否在已选中的日期列表中（A或B状态）
          const isInSelectedDates = this.selectedDatesA.includes(dateStr) || this.selectedDatesB.includes(dateStr);
          
          // A模式：如果日期已经在选中列表中，不禁用（允许取消选中和操作）
          // B模式：即使日期在选中列表中，也要根据 applicationDeadline 判断是否禁用
          if (isInSelectedDates) {
            // B模式（二类商家申请调用模式）：即使日期在选中列表中，也要根据 applicationDeadline 判断
            if (this.businessType === 2 && this.isApplyCall && this.currentSelectMode === 'B') {
              // 根据 applicationDeadline 判断是否禁用
              const now = new Date();
              const deadlineDays = this.applicationDeadline || 15;
              const deadlineTime = new Date(now);
              // B模式：当日不可选，"当前日期 + applicationDeadline"那天也不可选
              // 例如：今天18号，applicationDeadline=7，则18+7=25，25号及之前禁用，26号及之后可选
              deadlineTime.setDate(now.getDate() + deadlineDays);
              
              const periodDate = new Date(dateStr);
              periodDate.setHours(0, 0, 0, 0);
              deadlineTime.setHours(0, 0, 0, 0);
              now.setHours(0, 0, 0, 0);
              
              // B模式：当日不可选，"当前日期 + applicationDeadline"那天也不可选
              // 例如：今天18号，applicationDeadline=7，则18+7=25
              // 18号（今天）：18 >= 25 = false，不可选 ✓
              // 25号（18+7）：25 >= 25 = true，不可选 ✓（使用 >= 确保25号也被禁用）
              // 26号：26 >= 25 = true，但26 > 25 = true，可选 ✓
              // 判断：日期必须 > deadlineTime 才可选，即 periodDate > deadlineTime
              // 但为了确保25号也被禁用，我们使用 periodDate > deadlineTime（25 > 25 = false，不可选）
              const isSelectable = periodDate > deadlineTime;
              const shouldDisable = !isSelectable;
              return shouldDisable;
            }
            // A模式：不禁用（允许取消选中和操作）
            return false;
          }
          
          // 对于"二类组团业务"从"申请调用"进入的情况，还需要检查日期是否在班期列表中
          // 如果日期在班期列表中，也需要根据 applicationDeadline 判断是否禁用（B模式）
          if (this.businessType === 2 && this.productType === 4 && this.isApplyCall) {
            const allPeriodDates = [];
            if (this.outerPeriodList && this.outerPeriodList.length > 0) {
              const outerDates = this.outerPeriodList.map(p => this.extractDateFromPeriod(p)).filter(d => d);
              allPeriodDates.push(...outerDates);
            }
            if (this.periodList && this.periodList.length > 0) {
              const periodDates = this.periodList.map(p => this.extractDateFromPeriod(p)).filter(d => d);
              allPeriodDates.push(...periodDates);
            }
            if (allPeriodDates.length > 0 && allPeriodDates.includes(dateStr)) {
              // B模式：即使日期在班期列表中，也要根据 applicationDeadline 判断是否禁用
              // 当日不可选，"当前日期 + applicationDeadline"那天也不可选
              const now = new Date();
              const deadlineDays = this.applicationDeadline || 15;
              const deadlineTime = new Date(now);
              // 例如：今天18号，applicationDeadline=7，则18+7=25，25号及之前禁用，26号及之后可选
              deadlineTime.setDate(now.getDate() + deadlineDays);
              
              const periodDate = new Date(dateStr);
              periodDate.setHours(0, 0, 0, 0);
              deadlineTime.setHours(0, 0, 0, 0);
              now.setHours(0, 0, 0, 0);
              
              // B模式：当日不可选，"当前日期 + applicationDeadline"那天也不可选
              // 例如：今天18号，applicationDeadline=7，则18+7=25
              // 18号（今天）：18 >= 25 = false，不可选 ✓
              // 25号（18+7）：25 >= 25 = true，不可选 ✓（使用 >= 确保25号也被禁用）
              // 26号：26 >= 25 = true，但26 > 25 = true，可选 ✓
              // 判断：日期必须 > deadlineTime 才可选，即 periodDate > deadlineTime
              // 但为了确保25号也被禁用，我们使用 periodDate > deadlineTime（25 > 25 = false，不可选）
              const isSelectable = periodDate > deadlineTime;
              const shouldDisable = !isSelectable;
              return shouldDisable;
            }
          }
          
          // 如果日期不在选中列表中，根据 applicationDeadline 判断是否可选
          // 对于一类商家或二类商家（非申请调用模式），使用 isDateSelectable 判断
          // 注意：isDateSelectable 返回 true 表示可选，false 表示不可选
          // disabledDates 返回 true 表示禁用，false 表示不禁用
          // 所以需要取反：!isDateSelectable(dateStr)
          if (this.businessType === 1 || (this.businessType === 2 && !this.isApplyCall)) {
            const isSelectable = this.isDateSelectable(dateStr);
            const shouldDisable = !isSelectable;
            return shouldDisable;
          }
          
          // 对于二类或三类商家（申请调用模式），如果允许编辑
          if (this.isType2OrType3) {
            // 对于B模式（二类商家申请调用模式），即使日期在 allowedSelectDates 中，也要根据 applicationDeadline 判断是否禁用
            if (this.businessType === 2 && this.isApplyCall) {
              // 优先根据 applicationDeadline 判断
              const now = new Date();
              const deadlineDays = this.applicationDeadline || 15;
              const deadlineTime = new Date(now);
              // B模式：当日不可选，"当前日期 + applicationDeadline"那天也不可选
              // 例如：今天18号，applicationDeadline=7，则18+7=25，25号及之前禁用，26号及之后可选
              deadlineTime.setDate(now.getDate() + deadlineDays);
              
              const periodDate = new Date(dateStr);
              periodDate.setHours(0, 0, 0, 0);
              deadlineTime.setHours(0, 0, 0, 0);
              now.setHours(0, 0, 0, 0);
              
              // B模式：当日不可选，"当前日期 + applicationDeadline"那天也不可选
              // 例如：今天18号，applicationDeadline=7，则18+7=25
              // 18号（今天）：18 >= 25 = false，不可选 ✓
              // 25号（18+7）：25 >= 25 = true，不可选 ✓（使用 >= 确保25号也被禁用）
              // 26号：26 >= 25 = true，但26 > 25 = true，可选 ✓
              // 判断：日期必须 > deadlineTime 才可选，即 periodDate > deadlineTime
              // 但为了确保25号也被禁用，我们使用 periodDate > deadlineTime（25 > 25 = false，不可选）
              const isSelectable = periodDate > deadlineTime;
              const shouldDisable = !isSelectable;
              return shouldDisable;
            }
            
            // 如果日期在 allowedSelectDates 中，则不禁用（非B模式的情况）
            if (this.allowedSelectDates && this.allowedSelectDates.length > 0) {
              const result = !this.allowedSelectDates.includes(dateStr);
              return result;
            }
            // 如果没有 allowedSelectDates，检查是否在 outerPeriodList 或 periodList 中
            // 合并所有班期列表的日期
            const allPeriodDates = [];
            if (this.outerPeriodList && this.outerPeriodList.length > 0) {
              const outerDates = this.outerPeriodList.map(p => this.extractDateFromPeriod(p)).filter(d => d);
              allPeriodDates.push(...outerDates);
            }
            if (this.periodList && this.periodList.length > 0) {
              const periodDates = this.periodList.map(p => this.extractDateFromPeriod(p)).filter(d => d);
              allPeriodDates.push(...periodDates);
            }
            // 如果日期在班期列表中，则不禁用
            if (allPeriodDates.length > 0) {
              const isInPeriodList = allPeriodDates.includes(dateStr);
              return !isInPeriodList;
            }
            // 如果日期不在班期列表中，对于二类商家（申请调用模式），根据 applicationDeadline 判断是否可选
            // 对于三类商家，默认禁用（因为只能操作已存在的班期）
            if (this.businessType === 2 && this.isApplyCall) {
              const isSelectable = this.isDateSelectable(dateStr);
              const shouldDisable = !isSelectable;
              return shouldDisable;
            }
            // 对于三类商家，默认禁用（因为只能操作已存在的班期）
            return true;
          }
          
          // 其他情况，不禁用
          return false;
        }
        
        // 如果不允许编辑，使用原有逻辑
        // 如果是二类组团业务或三类商家
        if (this.isType2OrType3) {
          if (this.allowedSelectDates && this.allowedSelectDates.length > 0) {
            // 如果日期不在 allowedSelectDates 中，则禁用
            return !this.allowedSelectDates.includes(dateStr);
          }
          // 如果没有 allowedSelectDates，禁用所有日期
          return true;
        }
        // 对于一类商家，根据 applicationDeadline 判断
        if (this.businessType === 1) {
          return !this.isDateSelectable(dateStr);
        }
        // 对于二类商家（非申请调用模式），根据 applicationDeadline 判断
        if (this.businessType === 2 && !this.isApplyCall) {
          return !this.isDateSelectable(dateStr);
        }
        // 默认不禁用任何日期
        return false;
      };
    }
  },


  onLoad(options) {
    // 设置状态栏样式
    uni.setNavigationBarColor({
      frontColor: '#ffffff',
      backgroundColor: '#1677FF',
      animation: {
        duration: 400,
        timingFunc: 'easeIn'
      }
    });

    this.getID(options);

    // 读取班期选择参数
    this.loadPeriodSelectParams();

    // 读取已存在的选中日期（从班期管理跳转过来时会传）
    this.loadExistingSelectedDates();

    // 如果是二类组团业务或三类商家，设置最小选中日期（防止取消选中）
    if ((this.isApplyCall && this.businessType === 2) || this.businessType === 3) {
      if (this.selectedDates && this.selectedDates.length > 0) {
        // 从已选中的日期中找出在allowedSelectDates中的日期
        if (this.allowedSelectDates && this.allowedSelectDates.length > 0) {
          this.minSelectedDates = this.selectedDates.filter(d => this.allowedSelectDates.includes(d));
        } else {
          this.minSelectedDates = [...this.selectedDates];
        }
      }
    }

    this.formatMarkedDates();
    this.checkButtonShowStatus();
  },

  onReady() {
    // 设置状态栏内容为白色（图标和文字）
    uni.setNavigationBarColor({
      frontColor: '#ffffff',
      backgroundColor: '#1677FF'
    });
    
    // iOS 兼容性：确保数据在页面渲染完成后正确初始化
    this.$nextTick(() => {
      this.$nextTick(() => {
        // 确保 selectedDatesA 和 selectedDatesB 数据正确
        if (this.selectedDatesA.length === 0 && this.selectedDatesB.length === 0) {
          // 如果数据为空，重新执行 autoSetStates
          this.autoSetStates();
        }
        // 强制更新视图，确保 CustomCalendar 组件正确渲染
        this.$forceUpdate();
      });
    });
  },

  onUnload() {
    // 清除定时器（如果存在）
    if (this.calendarWatcher) {
      clearInterval(this.calendarWatcher);
      this.calendarWatcher = null;
    }
  },

  methods: {
    getID(options) {
      let id;
      if (options && options.id) {
        id = options.id;
      }
      this.id = id;
    },

    // 加载已存在的选中日期
    loadExistingSelectedDates() {
      try {
        const existingDatesStr = uni.getStorageSync('existingSelectedDates');
        if (existingDatesStr) {
          const existingDates = JSON.parse(existingDatesStr);

          // 将日期转换为日期字符串格式
          const dateStrings = existingDates.map(item => {
            // 如果有 DateName 字段（格式: 2025-10-31）
            if (item.DateName) {
              return item.DateName;
            }
            // 如果有 Datevalue 字段
            if (item.Datevalue) {
              return item.Datevalue;
            }
            // 如果有 date 字段
            if (item.date) {
              return item.date;
            }
            return null;
          }).filter(d => d);

          // 如果是二类组团业务或三类商家，只保留在allowedSelectDates中的日期
          let finalDateStrings = dateStrings;
          if ((this.isApplyCall && this.businessType === 2) || this.businessType === 3) {
            if (this.allowedSelectDates && this.allowedSelectDates.length > 0) {
              finalDateStrings = dateStrings.filter(d => this.allowedSelectDates.includes(d));
            } else {
              console.log('转换后的日期字符串:', dateStrings);
            }
          } else {
            console.log('转换后的日期字符串:', dateStrings);
          }

          // 将已存在的选中日期设置为A状态（创建状态）
          // 如果已经有A状态的日期，合并去重
          if (finalDateStrings && finalDateStrings.length > 0) {
            finalDateStrings.forEach(dateStr => {
              if (!this.selectedDatesA.includes(dateStr)) {
                this.selectedDatesA.push(dateStr);
              }
            });
            console.log('已将已存在的选中日期设置为A状态:', this.selectedDatesA);
          }

          // 更新兼容字段
          this.selectedDatesArray = finalDateStrings;
          this.selectedDates = finalDateStrings;

          // 读取后清除 storage
          uni.removeStorageSync('existingSelectedDates');
        }
      } catch (e) {
        console.error('读取已存在日期失败:', e);
      }
    },

    // 读取班期选择参数
    loadPeriodSelectParams() {
      try {
        const paramsStr = uni.getStorageSync('periodSelectParams');
        if (paramsStr) {
          const params = JSON.parse(paramsStr);
          this.businessType = params.businessType || 1;
          this.isApplyCall = params.isApplyCall || false;
          this.applicationDeadline = params.applicationDeadline || 15;
          this.productId = params.productId || 0;
          // 确保 productType 是数字类型
          this.productType = Number(params.productType) || 0;
          console.log('读取 productType:', this.productType, '原始值:', params.productType, '类型:', typeof this.productType);
          // 明确读取 allowEdit，确保从 periodCreate 进入时可以编辑
          this.allowEdit = params.allowEdit === true || params.allowEdit === 'true'; // 读取是否允许编辑
          console.log('读取班期选择参数:', params);
          console.log('allowEdit 值:', this.allowEdit, '类型:', typeof this.allowEdit);
          // 读取后清除
          uni.removeStorageSync('periodSelectParams');
        } else {
          console.log('未找到 periodSelectParams，使用默认值');
        }
      } catch (e) {
        console.error('读取班期选择参数失败:', e);
      }

      // 读取班期列表
      try {
        const periodListStr = uni.getStorageSync('periodList');
        if (periodListStr) {
          this.periodList = JSON.parse(periodListStr);
          console.log('读取班期列表:', this.periodList);
          // 注意：不要立即清除，因为 disabledDates 计算属性可能需要使用
        }
      } catch (e) {
        console.error('读取班期列表失败:', e);
      }
      
      // 读取外层班期列表（用于二类组团业务）
      try {
        const outerPeriodListStr = uni.getStorageSync('outerPeriodList');
        if (outerPeriodListStr) {
          this.outerPeriodList = JSON.parse(outerPeriodListStr);
          console.log('读取外层班期列表:', this.outerPeriodList);
          // 注意：不要立即清除，因为 disabledDates 计算属性可能需要使用
        }
      } catch (e) {
        console.error('读取外层班期列表失败:', e);
      }

      // 读取允许选择的日期（二类组团业务和三类商家）
      // 注意：必须在读取businessType和isApplyCall之后
      if ((this.isApplyCall && this.businessType === 2) || this.businessType === 3) {
        try {
          const allowedDatesStr = uni.getStorageSync('allowedSelectDates');
          if (allowedDatesStr) {
            this.allowedSelectDates = JSON.parse(allowedDatesStr);
            console.log('读取允许选择的日期:', this.allowedSelectDates);
            // 读取后清除
            uni.removeStorageSync('allowedSelectDates');
          }
        } catch (e) {
          console.error('读取允许选择的日期失败:', e);
        }
      }

      // 根据业务类型和产品类型判断是否只读模式
      // 只读模式：用户无法手动更改AB状态，状态由外部数据决定
      // 注意：必须在读取 allowEdit 之后调用
      this.isReadonlyMode = this.shouldBeReadonlyMode();
      console.log('最终 isReadonlyMode:', this.isReadonlyMode, 'allowEdit:', this.allowEdit);
      
      // 自动设置A和B状态
      this.autoSetStates();
      
      // 设置完状态后，清除 storage（避免影响 disabledDates 计算属性）
      // 注意：需要在 autoSetStates 之后清除，因为 autoSetStates 可能会使用这些数据
      try {
        uni.removeStorageSync('periodList');
        uni.removeStorageSync('outerPeriodList');
      } catch (e) {
        console.error('清除班期列表 storage 失败:', e);
      }
    },
    
    // 判断是否应该为只读模式
    shouldBeReadonlyMode() {
      // 如果明确允许编辑（从合作申请管理页面或上架设置页面进入），则不是只读模式
      if (this.allowEdit) {
        console.log('allowEdit 为 true，允许编辑，不是只读模式');
        return false;
      }
      // 如果是从产品详情进入的，或者是二类/三类商家，则为只读模式
      // 一类商家可以手动设置，二类三类商家根据产品类型自动设置
      if (this.businessType === 2 || this.businessType === 3) {
        console.log('二类或三类商家，且未允许编辑，设置为只读模式');
        return true;
      }
      // 一类商家也可以设置为只读模式（如果传入了班期列表且未允许编辑）
      if (this.businessType === 1 && this.periodList && this.periodList.length > 0 && !this.allowEdit) {
        console.log('一类商家，有班期列表且未允许编辑，设置为只读模式');
        return true;
      }
      console.log('默认允许编辑，不是只读模式');
      return false;
    },
    
    // 自动设置A和B状态
    autoSetStates() {
      // 先读取外层的班期列表（A状态的基础数据）
      let outerPeriodDates = [];
      // 如果 outerPeriodList 已经在 data 中（从 loadPeriodSelectParams 读取），直接使用
      if (this.outerPeriodList && this.outerPeriodList.length > 0) {
        this.outerPeriodList.forEach(period => {
          let dateStr = this.extractDateFromPeriod(period);
          if (dateStr) {
            outerPeriodDates.push(dateStr);
          }
        });
        console.log('使用已读取的外层班期列表（A状态）:', outerPeriodDates);
      } else {
        // 否则从 storage 读取
        try {
          const outerPeriodListStr = uni.getStorageSync('outerPeriodList');
          if (outerPeriodListStr) {
            const outerPeriodList = JSON.parse(outerPeriodListStr);
            // 保存到 data 中，供 disabledDates 计算属性使用
            this.outerPeriodList = outerPeriodList;
            outerPeriodList.forEach(period => {
              let dateStr = this.extractDateFromPeriod(period);
              if (dateStr) {
                outerPeriodDates.push(dateStr);
              }
            });
            console.log('读取外层班期列表（A状态）:', outerPeriodDates);
          }
        } catch (e) {
          console.error('读取外层班期列表失败:', e);
        }
      }

      // 从当前班期列表中提取日期
      const currentPeriodDates = [];
      const currentPeriodSelectedDates = []; // 已选中的日期（用于B状态）
      if (this.periodList && this.periodList.length > 0) {
        this.periodList.forEach(period => {
          let dateStr = this.extractDateFromPeriod(period);
          if (dateStr) {
            currentPeriodDates.push(dateStr);
            // 如果班期对象中有 isSelected 属性且为 true，则添加到已选中列表
            if (period.isSelected === true || period.isSelected === 'true') {
              currentPeriodSelectedDates.push(dateStr);
            }
          }
        });
      }

      // 根据业务类型和产品类型设置A和B状态
      // A状态：一类商家的泛营期设置，二类商家的综合研学与目的地接待
      // B状态：二类商家的组团业务，三类商家的研学活动
      
      // 确保 productType 是数字类型
      // 处理字符串 '4' 或数字 4 的情况
      let productTypeNum = 0;
      if (this.productType !== null && this.productType !== undefined) {
        if (typeof this.productType === 'string') {
          productTypeNum = parseInt(this.productType, 10) || 0;
        } else {
          productTypeNum = Number(this.productType) || 0;
        }
      }
      console.log('autoSetStates - businessType:', this.businessType, 'productType:', this.productType, 'productType类型:', typeof this.productType, 'productTypeNum:', productTypeNum);
      console.log('autoSetStates - 判断条件: productTypeNum === 2?', productTypeNum === 2, 'productTypeNum === 3?', productTypeNum === 3, 'productTypeNum === 4?', productTypeNum === 4);
      
      if (this.businessType === 1) {
        // 一类商家：所有班期都是A状态（创建状态）
        this.selectedDatesA = [...currentPeriodDates];
        this.selectedDatesB = [];
        // 一类商家：自动设置为A模式（创建状态）
        this.currentSelectMode = 'A';
        console.log('一类商家：设置为A模式（创建状态）');
      } else if (this.businessType === 2) {
        // 二类商家
        // A状态：外层的班期列表（如果存在）或当前班期列表
        this.selectedDatesA = outerPeriodDates.length > 0 ? [...outerPeriodDates] : [...currentPeriodDates];
        
        console.log('二类商家 - 判断 productTypeNum:', productTypeNum, 'isApplyCall:', this.isApplyCall);
        
        // 判断是A模式还是B模式
        // 申请调用模式下，根据 productType、businessType 和 businessEntry 的组合判断
        // 非申请调用模式，根据 productType 判断
        let isBMode = false;
        if (this.isApplyCall) {
          // 🔑 获取 businessEntry 用于区分直接创建和组团业务调用
          const businessEntry = uni.getStorageSync('businessEntry') || '';
          
          // 申请调用模式：根据 productType、businessType 和 businessEntry 的组合判断
          // productType === 1 且 businessType === 2 → 申请调用的组团业务状态（B模式）
          if (productTypeNum === 1 && this.businessType === 2) {
            isBMode = true;
          }
          // productType === 3 且 businessType === 2 的情况需要区分：
          else if (productTypeNum === 3 && this.businessType === 2) {
            // 通过组团业务调用目的地接待产品 → B模式
            if (businessEntry === 'group_travel') {
              console.log('✅ dateUtilPage: 组团业务调用目的地接待产品 → B模式');
              isBMode = true;
            }
            // 直接创建目的地接待 → A模式
            else if (businessEntry === 'dest_receive') {
              console.log('✅ dateUtilPage: 直接创建目的地接待 → A模式');
              isBMode = false;
            }
            // 兜底：默认A模式（目的地研学的调用状态）
            else {
              console.log('⚠️ dateUtilPage: 未匹配到 businessEntry，默认A模式（目的地研学的调用状态）');
              isBMode = false;
            }
          }
          // 其他申请调用情况，默认根据 productType 判断
          else {
            // productType 4 或 5 为 B 模式，productType 1, 2, 3 为 A 模式
            isBMode = productTypeNum === 4 || productTypeNum === 5;
          }
        } else {
          // 非申请调用模式：根据 productType 判断
          // productType 4 或 5 为 B 模式，productType 1, 2, 3 为 A 模式
          isBMode = productTypeNum === 4 || productTypeNum === 5;
        }
        
        if (!isBMode) {
          // A模式：综合研学业务(2) 或 目的地接待(3) 或 其他A模式情况
          // 当前班期也是A状态
          currentPeriodDates.forEach(date => {
            if (!this.selectedDatesA.includes(date)) {
              this.selectedDatesA.push(date);
            }
          });
          this.selectedDatesB = [];
          // 自动设置为A模式（创建状态）
          this.currentSelectMode = 'A';
          console.log('二类商家（A模式）：设置为A模式（创建状态），productTypeNum:', productTypeNum, 'isApplyCall:', this.isApplyCall);
        } else {
          // B模式：组团业务(4) 或 申请调用模式（productType=1且businessType=2 或 productType=3且businessType=3）
          // B状态：根据外层班期列表中已选中的日期来显示
          // 如果外层全都没选中，B状态也应该是空的（未选中），而不是默认全部选中
          this.selectedDatesB = currentPeriodSelectedDates.length > 0 ? [...currentPeriodSelectedDates] : [];
          // 确保B状态的日期也在A状态中
          this.selectedDatesB.forEach(date => {
            if (!this.selectedDatesA.includes(date)) {
              this.selectedDatesA.push(date);
            }
          });
          // 自动设置为B模式（申请调用状态）
          this.currentSelectMode = 'B';
          console.log('二类商家（B模式）：设置为B模式（申请调用状态），productTypeNum:', productTypeNum, 'isApplyCall:', this.isApplyCall);
          console.log('B状态已选中日期:', this.selectedDatesB, '从外层班期列表选中状态获取');
        }
      } else if (this.businessType === 3) {
        // 三类商家
        // A状态：外层的班期列表（如果存在）
        this.selectedDatesA = outerPeriodDates.length > 0 ? [...outerPeriodDates] : [];
        
        if (productTypeNum === 5) {
          // 研学活动(5)：B状态根据外层班期列表中已选中的日期来显示
          // 如果外层全都没选中，B状态也应该是空的（未选中），而不是默认全部选中
          this.selectedDatesB = currentPeriodSelectedDates.length > 0 ? [...currentPeriodSelectedDates] : [];
          // 确保B状态的日期也在A状态中
          this.selectedDatesB.forEach(date => {
            if (!this.selectedDatesA.includes(date)) {
              this.selectedDatesA.push(date);
            }
          });
        } else {
          // 其他情况：默认A状态
          currentPeriodDates.forEach(date => {
            if (!this.selectedDatesA.includes(date)) {
              this.selectedDatesA.push(date);
            }
          });
          this.selectedDatesB = [];
        }
        // 三类商家：自动设置为B模式（申请调用状态）
        this.currentSelectMode = 'B';
        console.log('三类商家：设置为B模式（申请调用状态）');
        console.log('B状态已选中日期:', this.selectedDatesB, '从外层班期列表选中状态获取');
      } else {
        // 默认：A状态
        this.selectedDatesA = [...currentPeriodDates];
        this.selectedDatesB = [];
        this.currentSelectMode = 'A';
        console.log('默认：设置为A模式（创建状态）');
      }

      console.log('自动设置状态 - A状态:', this.selectedDatesA, 'B状态:', this.selectedDatesB, 'currentSelectMode:', this.currentSelectMode);
      
      // 更新兼容字段
      this.selectedDates = [...this.selectedDatesA, ...this.selectedDatesB];
      this.selectedDatesArray = [...this.selectedDatesA, ...this.selectedDatesB];
    },
    
    // 从班期对象中提取日期字符串
    extractDateFromPeriod(period) {
      if (!period) return null;
      
      // 提取日期，支持多种格式
      let dateStr = null;
      if (period.DateName) {
        dateStr = period.DateName;
      } else if (period.Datevalue) {
        dateStr = period.Datevalue;
      } else if (period.date) {
        // 如果是 MM/DD 格式，需要转换为 YYYY-MM-DD
        if (period.date.includes('/')) {
          const [month, day] = period.date.split('/');
          const today = new Date();
          dateStr = `${today.getFullYear()}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
        } else {
          dateStr = period.date;
        }
      }
      
      return dateStr;
    },

    // 测试添加日期
    testAddDate() {
      const today = new Date();
      const dateStr = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
      this.selectedDates = [dateStr];
      this.selectedDatesArray = [dateStr];
      console.log('测试添加日期:', dateStr);
      this.formatMarkedDates();
      this.checkButtonShowStatus();
    },

    // 判断日期是否可选（基于applicationDeadline）
    isDateSelectable(dateStr) {
      if (!dateStr) {
        console.log('isDateSelectable: dateStr 为空，返回 false');
        return false;
      }

      console.log('isDateSelectable - dateStr:', dateStr, 'businessType:', this.businessType, 'isApplyCall:', this.isApplyCall, 'applicationDeadline:', this.applicationDeadline);

      // 如果是二类组团业务或三类商家（申请调用模式），优先检查是否在allowedSelectDates中
      // 但是，如果 allowEdit 为 true（从 periodCreate 进入），且日期不在班期列表中，应该根据 applicationDeadline 判断
      if ((this.isApplyCall && this.businessType === 2) || this.businessType === 3) {
        // 如果 allowEdit 为 true，且日期不在班期列表中，根据 applicationDeadline 判断
        if (this.allowEdit) {
          // 检查日期是否在班期列表中
          const allPeriodDates = [];
          if (this.outerPeriodList && this.outerPeriodList.length > 0) {
            const outerDates = this.outerPeriodList.map(p => this.extractDateFromPeriod(p)).filter(d => d);
            allPeriodDates.push(...outerDates);
          }
          if (this.periodList && this.periodList.length > 0) {
            const periodDates = this.periodList.map(p => this.extractDateFromPeriod(p)).filter(d => d);
            allPeriodDates.push(...periodDates);
          }
          // 如果日期不在班期列表中，根据 applicationDeadline 判断
          if (allPeriodDates.length === 0 || !allPeriodDates.includes(dateStr)) {
            // 对于二类商家（申请调用模式），根据 applicationDeadline 判断
            if (this.businessType === 2 && this.isApplyCall) {
              const now = new Date();
              const deadlineDays = this.applicationDeadline || 15;
              const deadlineTime = new Date(now);
              deadlineTime.setDate(now.getDate() + deadlineDays);

              const periodDate = new Date(dateStr);
              periodDate.setHours(0, 0, 0, 0);
              deadlineTime.setHours(0, 0, 0, 0);

              const result = periodDate > deadlineTime;
              console.log('isDateSelectable - 二类商家（申请调用模式）但日期不在班期列表中，根据 applicationDeadline 判断:', {
                dateStr,
                now: now.toISOString(),
                deadlineDays,
                deadlineTime: deadlineTime.toISOString(),
                periodDate: periodDate.toISOString(),
                result
              });
              return result;
            }
            // 对于三类商家，如果日期不在班期列表中，不允许选择
            console.log('isDateSelectable - 三类商家但日期不在班期列表中，返回 false');
            return false;
          }
        }
        
        // 如果 allowEdit 为 false，或者日期在班期列表中，检查是否在allowedSelectDates中
        if (this.allowedSelectDates && this.allowedSelectDates.length > 0) {
          const result = this.allowedSelectDates.includes(dateStr);
          console.log('isDateSelectable - 二类/三类商家（申请调用模式）allowedSelectDates 判断:', result);
          return result;
        }
        // 如果没有allowedSelectDates，则不允许选择（这种情况不应该发生）
        console.log('isDateSelectable - 二类/三类商家（申请调用模式）但没有 allowedSelectDates，返回 false');
        return false;
      }

      // 一类商家或二类商家（非申请调用模式）：检查日期是否在applicationDeadline之后
      // 逻辑：如果日期在 (当前时间 + applicationDeadline) 之后，则可选
      if (this.businessType === 1 || (this.businessType === 2 && !this.isApplyCall)) {
        const now = new Date();
        const deadlineDays = this.applicationDeadline || 15;
        const deadlineTime = new Date(now);
        deadlineTime.setDate(now.getDate() + deadlineDays);

        const periodDate = new Date(dateStr);
        periodDate.setHours(0, 0, 0, 0);
        deadlineTime.setHours(0, 0, 0, 0);

        const result = periodDate > deadlineTime;
        return result;
      }

      // 其他情况：默认允许选择
      console.log('isDateSelectable - 其他情况，默认允许选择');
      return true;
    },

    // 日历日期点击事件（自定义日历组件）
    onDayClick(dateStr, status, action) {
      console.log('日期点击:', dateStr, '状态:', status, '操作:', action);
    },
    
    // 日历变化事件（自定义日历组件）
    onCalendarChange(selectedA, selectedB) {
      console.log('日历变化 - A状态:', selectedA, 'B状态:', selectedB);
      this.selectedDatesA = selectedA;
      this.selectedDatesB = selectedB;
      
      // 更新兼容字段
      this.selectedDates = [...selectedA, ...selectedB];
      this.selectedDatesArray = [...selectedA, ...selectedB];
      
      // 格式化日期
      this.formatMarkedDates();
      this.checkButtonShowStatus();
    },
    
    // 月份切换事件
    onMonthChange(year, month) {
      console.log('月份切换:', year, month);
    },
    
    // 切换到A模式
    switchToModeA() {
      // 二类组团业务且是申请调用模式：不允许切换到A模式，只能操作B状态
      if (this.businessType === 2 && this.productType === 4 && this.allowEdit && this.isApplyCall) {
        uni.showToast({
          title: '只能操作申请调用状态',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      this.currentSelectMode = 'A';
      // 更新底部显示（A模式显示A模式列表）
      this.formatMarkedDates();
      this.checkButtonShowStatus();
    },
    
    // 切换到B模式
    switchToModeB() {
      // 切换到B模式前，检查是否有A状态的日期
      if (this.selectedDatesA.length === 0) {
        uni.showToast({
          title: '请先选择A状态日期',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      this.currentSelectMode = 'B';
      // 更新底部显示（B模式显示B模式列表）
      this.formatMarkedDates();
      this.checkButtonShowStatus();
    },
    
    // 日历确认选择（保留兼容，但主要使用 onCalendarChange）
    onCalendarConfirm(e) {
      // 这个方法保留用于兼容，但自定义日历组件不使用
      console.log('onCalendarConfirm (兼容方法):', e);
    },

    BackPage() {
      uni.navigateBack({
        delta: 1
      });
    },

    toHome() {
      uni.redirectTo({
        url: '/pages/JiDi/my/index'
      });
    },

    // 切换用户标记展开状态
    toggleUserExpand() {
      this.showUserExpand = !this.showUserExpand;
    },

    // 切换初始标记展开状态
    toggleInitialExpand() {
      this.showInitialExpand = !this.showInitialExpand;
    },

    // 格式化标记日期
    formatMarkedDates() {
      const formatDate = (dateStr) => {
        console.log('格式化日期:', dateStr);
        try {
          const d = new Date(dateStr);
          const formatted = {
            year: d.getFullYear(),
            month: d.getMonth() + 1,
            day: d.getDate(),
            weekDay: this.weekDays[d.getDay()]
          };
          console.log('格式化结果:', formatted);
          return formatted;
        } catch (e) {
          console.error('日期格式化失败:', dateStr, e);
          return null;
        }
      };

      // 根据当前选择模式决定显示哪个列表
      // A模式：显示A模式列表（selectedDatesA）
      // B模式：显示B模式列表（selectedDatesB）
      let dates = [];
      if (this.currentSelectMode === 'A') {
        dates = Array.isArray(this.selectedDatesA) ? this.selectedDatesA : [];
        console.log('A模式：显示A模式列表（selectedDatesA）:', dates);
      } else if (this.currentSelectMode === 'B') {
        dates = Array.isArray(this.selectedDatesB) ? this.selectedDatesB : [];
        console.log('B模式：显示B模式列表（selectedDatesB）:', dates);
      } else {
        // 兼容旧逻辑：合并A和B状态的日期用于显示
        const allSelectedDates = [...new Set([...this.selectedDatesA, ...this.selectedDatesB])];
        dates = Array.isArray(allSelectedDates) ? allSelectedDates : [allSelectedDates];
        console.log('所有选中日期（A和B合并去重）:', dates);
      }

      let formatted = dates.filter(d => d && d !== '' && d !== undefined).map(formatDate).filter(d => d !== null);

      // 对日期进行排序（按年月日升序）
      formatted.sort((a, b) => {
        if (a.year !== b.year) {
          return a.year - b.year;
        }
        if (a.month !== b.month) {
          return a.month - b.month;
        }
        return a.day - b.day;
      });

      this.formattedUserMarkedDates = formatted;
      console.log('formattedUserMarkedDates:', this.formattedUserMarkedDates);

      // 对初始标记日期也进行排序
      let initialFormatted = this.initialMarkedDates.map(formatDate);
      initialFormatted.sort((a, b) => {
        if (a.year !== b.year) {
          return a.year - b.year;
        }
        if (a.month !== b.month) {
          return a.month - b.month;
        }
        return a.day - b.day;
      });

      this.formattedInitialMarkedDates = initialFormatted;
    },

    // 检查按钮是否需要显示
    checkButtonShowStatus() {
      const { formattedUserMarkedDates, formattedInitialMarkedDates } = this;
      const { windowWidth } = uni.getSystemInfoSync();
      const itemWidth = 104 + 15; // 日期块宽度+间距（rpx）

      const userTotalWidth = formattedUserMarkedDates.length * itemWidth;
      const initialTotalWidth = formattedInitialMarkedDates.length * itemWidth;

      this.userButtonShow = userTotalWidth > windowWidth;
      this.initialButtonShow = initialTotalWidth > windowWidth;
    },

    convertDateObjects(arr) {
      console.log('看看',arr)
      return arr.map(item => {
        const year = item.year;
        const month = String(item.month).padStart(2, '0');
        const day = String(item.day).padStart(2, '0');
        const weekDay = item.weekDay;
        const dateStr = `${year}-${month}-${day}`;

        // 🔑 尝试从 A 模式传过来的数据中获取 periodId
        let periodId = null;
        
        // 优先从 outerPeriodList 中查找（A 模式的外层班期列表）
        if (this.outerPeriodList && this.outerPeriodList.length > 0) {
          const period = this.outerPeriodList.find(p => {
            const pDateStr = this.extractDateFromPeriod(p);
            return pDateStr === dateStr;
          });
          if (period) {
            periodId = period.id || period.periodId;
            if (periodId) {
              console.log('✅ convertDateObjects: 从 outerPeriodList 找到 A 模式传过来的原始 periodId:', periodId);
            }
          }
        }
        
        // 如果 outerPeriodList 中没有找到，尝试从 periodList 中查找
        if (!periodId && this.periodList && this.periodList.length > 0) {
          const period = this.periodList.find(p => {
            const pDateStr = this.extractDateFromPeriod(p);
            return pDateStr === dateStr;
          });
          if (period) {
            periodId = period.id || period.periodId;
            if (periodId) {
              console.log('✅ convertDateObjects: 从 periodList 找到 A 模式传过来的原始 periodId:', periodId);
            }
          }
        }

        // 构建新对象，确保格式与DateCard组件期望的一致
        return {
          DateName: dateStr,
          Datevalue: dateStr,
          Datevalue1: `${month}/${day}`,
          date: `${month}/${day}`, // 确保DateCard组件能正确显示日期
          WeekName: `周${weekDay}`,
          id: periodId,
          periodId: periodId, // 🔑 使用 A 模式传过来的原始 periodId
          mycheck: true,
          is: true, // 标记为选中状态
          isSelected: true // A模式下，所有选中的日期都应该标记为 isSelected: true
        };
      });
    },

    confirmSelect() {
      // 判断是A模式还是B模式
      // 申请调用模式下，根据 productType 和 businessType 的组合判断
      // 非申请调用模式，根据 productType 判断
      const productTypeNum = Number(this.productType) || 0;
      const businessTypeNum = Number(this.businessType) || 0;
      let isBMode = false;
      
      if (this.isApplyCall) {
        // 申请调用模式：根据 productType 和 businessType 的组合判断
        // productType === 1 且 businessType === 2 → 申请调用的组团业务状态（B模式）
        if (productTypeNum === 1 && businessTypeNum === 2) {
          isBMode = true;
        }
        // productType === 3 且 businessType === 2 → 目的地研学的调用状态（A模式）
        else if (productTypeNum === 3 && businessTypeNum === 2) {
          isBMode = false;
        }
        // productType === 3 且 businessType === 3 → 三类商家申请调用状态（B模式）
        else if (productTypeNum === 3 && businessTypeNum === 3) {
          isBMode = true;
        }
        // 其他申请调用情况，默认根据 productType 判断
        else {
          // productType 4 或 5 为 B 模式，productType 1, 2, 3 为 A 模式
          isBMode = productTypeNum === 4 || productTypeNum === 5;
        }
      } else {
        // 非申请调用模式：根据 productType 判断
        // productType 4 或 5 为 B 模式，productType 1, 2, 3 为 A 模式
        isBMode = productTypeNum === 4 || productTypeNum === 5;
      }
      
      
      // 如果是B模式（申请调用模式），需要保存所有A状态的班期数据，并根据B状态标记选中状态
      if (isBMode && (this.allowEdit || this.isApplyCall)) {
        // 获取所有A状态的班期数据（从 outerPeriodList 或 selectedDatesA 获取）
        let allPeriodDates = [];
        if (this.outerPeriodList && this.outerPeriodList.length > 0) {
          // 如果有外层班期列表，使用外层班期列表
          allPeriodDates = this.outerPeriodList.map(period => {
            const dateStr = this.extractDateFromPeriod(period);
            if (!dateStr) return null;
            
            const [year, month, day] = dateStr.split('-').map(Number);
            const date = new Date(year, month - 1, day);
            const weekDay = date.getDay();
            const weekDayNames = ['日', '一', '二', '三', '四', '五', '六'];
            
            // 检查这个日期是否在B状态中
            const isSelected = this.selectedDatesB.includes(dateStr);
            
            // 🔑 获取 periodId：直接使用 A 模式传过来的原始 id
            // 优先使用 period.id 或 period.periodId（A 模式传过来的原始 id）
            let periodId = period.id || period.periodId;
            
            // 如果没有 periodId，使用日期数字作为后备（但这不是理想情况）
            if (!periodId) {
              periodId = `${year}${String(day).padStart(2, '0')}${String(month).padStart(2, '0')}`;
              console.warn('⚠️ 未找到 periodId，使用日期数字作为后备:', periodId);
            } else {
              console.log('✅ 使用 A 模式传过来的原始 periodId:', periodId);
            }
            
            // 确保 isSelected 是布尔值
            const finalIsSelected = isSelected === true || isSelected === 'true' || isSelected === 1;
            
            return {
              ...period, // 保留原始数据
              DateName: dateStr,
              Datevalue: dateStr,
              Datevalue1: `${String(month).padStart(2, '0')}/${String(day).padStart(2, '0')}`,
              date: `${String(month).padStart(2, '0')}/${String(day).padStart(2, '0')}`,
              WeekName: `周${weekDayNames[weekDay]}`,
              id: periodId,
              periodId: periodId, // 🔑 使用 A 模式传过来的原始 periodId
              mycheck: true,
              is: finalIsSelected,
              isSelected: finalIsSelected // 明确标记选中状态，确保是布尔值，放在最后避免被覆盖
            };
          }).filter(p => p !== null);
        } else {
          // 如果没有外层班期列表，从 selectedDatesA 生成
          // 如果 selectedDatesA 为空，尝试从 periodList 获取
          let sourceDates = this.selectedDatesA;
          if (!sourceDates || sourceDates.length === 0) {
            // 如果 selectedDatesA 为空，从 periodList 提取日期
            if (this.periodList && this.periodList.length > 0) {
              sourceDates = this.periodList.map(period => {
                const dateStr = this.extractDateFromPeriod(period);
                return dateStr;
              }).filter(d => d);
            }
          }
          
          allPeriodDates = sourceDates.map(dateStr => {
            const [year, month, day] = dateStr.split('-').map(Number);
            const date = new Date(year, month - 1, day);
            const weekDay = date.getDay();
            const weekDayNames = ['日', '一', '二', '三', '四', '五', '六'];
            
            // 检查这个日期是否在B状态中
            const isSelected = this.selectedDatesB.includes(dateStr);
            
            // 🔑 尝试从 periodList 中获取 periodId：直接使用 A 模式传过来的原始 id
            let periodId = null;
            if (this.periodList && this.periodList.length > 0) {
              const period = this.periodList.find(p => {
                const pDateStr = this.extractDateFromPeriod(p);
                return pDateStr === dateStr;
              });
              if (period) {
                // 直接使用 period.id 或 period.periodId（A 模式传过来的原始 id）
                periodId = period.id || period.periodId;
                if (periodId) {
                  console.log('✅ 从 periodList 找到 A 模式传过来的原始 periodId:', periodId);
                }
              }
            }
            
            // 如果没有找到 periodId，使用日期数字作为后备（但这不是理想情况）
            if (!periodId) {
              periodId = `${year}${String(day).padStart(2, '0')}${String(month).padStart(2, '0')}`;
              console.warn('⚠️ 未找到 periodId，使用日期数字作为后备:', periodId);
            }
            
            // 确保 isSelected 是布尔值
            const finalIsSelected = isSelected === true || isSelected === 'true' || isSelected === 1;
            
            return {
              DateName: dateStr,
              Datevalue: dateStr,
              Datevalue1: `${String(month).padStart(2, '0')}/${String(day).padStart(2, '0')}`,
              date: `${String(month).padStart(2, '0')}/${String(day).padStart(2, '0')}`,
              WeekName: `周${weekDayNames[weekDay]}`,
              id: periodId,
              periodId: periodId, // 🔑 使用 A 模式传过来的原始 periodId
              mycheck: true,
              is: finalIsSelected,
              isSelected: finalIsSelected // 明确标记选中状态，确保是布尔值
            };
          });
        }
        
        // 保存所有A状态的班期数据（包含选中状态标记）
        uni.setStorageSync('selectedDates', JSON.stringify(allPeriodDates));
        
        // 保存B状态的日期列表，供外层班期列表使用
        uni.setStorageSync('selectedDatesBForPeriodList', JSON.stringify(this.selectedDatesB));
      } else {
        // 🔑 A模式或其他情况：根据日期从 outerPeriodList（A状态数据）中找出对应的原始数据
        const selectedDates = this.convertDateObjects(this.formattedUserMarkedDates);
        
        // 🔑 如果有 outerPeriodList，根据日期匹配找出原始A状态数据
        if (this.outerPeriodList && this.outerPeriodList.length > 0) {
          const matchedSelectedDates = selectedDates.map(dateItem => {
            const dateStr = dateItem.DateName;
            // 从 outerPeriodList 中查找匹配的原始数据
            const matchedPeriod = this.outerPeriodList.find(period => {
              const pDateStr = this.extractDateFromPeriod(period);
              return pDateStr === dateStr;
            });
            
            if (matchedPeriod) {
              // 🔑 找到匹配的原始A状态数据，合并所有字段
              return {
                ...matchedPeriod, // 🔑 保留原始A状态数据的所有字段
                DateName: dateItem.DateName,
                Datevalue: dateItem.Datevalue,
                Datevalue1: dateItem.Datevalue1,
                date: dateItem.date,
                WeekName: dateItem.WeekName,
                id: matchedPeriod.id || matchedPeriod.periodId || dateItem.id,
                periodId: matchedPeriod.id || matchedPeriod.periodId || dateItem.periodId,
                mycheck: dateItem.mycheck,
                is: dateItem.is,
                isSelected: dateItem.isSelected
              };
            } else {
              // 如果没有找到匹配的原始数据，使用转换后的数据
              console.warn('⚠️ 未在 outerPeriodList 中找到日期对应的原始A状态数据:', dateStr);
              return dateItem;
            }
          });
          
          console.log('✅ A模式：根据日期从 outerPeriodList 中找出原始A状态数据，共', matchedSelectedDates.length, '个');
          uni.setStorageSync('selectedDates', JSON.stringify(matchedSelectedDates));
        } else {
          // 如果没有 outerPeriodList，使用转换后的数据
          uni.setStorageSync('selectedDates', JSON.stringify(selectedDates));
        }
      }
      
      // 同时保存A和B状态的日期
      uni.setStorageSync('selectedDatesA', JSON.stringify(this.selectedDatesA));
      uni.setStorageSync('selectedDatesB', JSON.stringify(this.selectedDatesB));

      this.BackPage();
    }
  }
}
</script>

<style lang="scss" scoped>
.calendar-container {
  padding: 20rpx;
  padding-bottom: 400rpx; /* 为底部固定区域留出空间 */
  // padding-top: 150rpx;
  background-color: #EDEDED;
  min-height: 100%;
  position: relative;
  /* iOS 兼容性：启用硬件加速，防止滚动时数据丢失 */
  transform: translateZ(0);
  -webkit-transform: translateZ(0);
}

/* 打开日历按钮 */
.open-calendar-btn {
  width: 100%;
  height: 80rpx;
  line-height: 80rpx;
  text-align: center;
  background-color: #1677FF;
  color: #ffffff;
  font-size: 32rpx;
  font-weight: 600;
  border-radius: 40rpx;
  margin-bottom: 30rpx;
  box-shadow: 0 4rpx 12rpx rgba(22, 119, 255, 0.3);
  transition: all 0.3s ease;

  &:active {
    transform: scale(0.98);
    background-color: #0d5dd6;
  }
}

/* 确定按钮 */
.confirm-btn {
  width: 100%;
  height: 80rpx;
  line-height: 80rpx;
  background-color: #1677FF;
  color: #ffffff;
  font-size: 32rpx;
  font-weight: 600;
  border: none;
  border-radius: 40rpx;
  box-shadow: 0 4rpx 12rpx rgba(22, 119, 255, 0.3);
  transition: all 0.3s ease;
  margin-bottom: 20rpx;

  &:active {
    transform: scale(0.98);
    background-color: #0d5dd6;
  }
}

/* 头部导航 */
.header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 15rpx 20rpx;
  margin-bottom: 20rpx;
}

.header .nav-btn {
  background: none;
  border: none;
  outline: none;
  padding: 0;
  width: 60rpx;
  height: 60rpx;
  display: flex;
  justify-content: center;
  align-items: center;
}

.header .title {
  font-size: 36rpx;
  font-weight: 600;
  color: #333;
}

.header .arrow {
  font-weight: 600;
  font-size: 32rpx;
  color: #666;
}

/* 星期标题 */
.week-title {
  display: grid;
  grid-template-columns: repeat(7, 1fr);
  margin-bottom: 15rpx;
}

.week-item {
  text-align: center;
  font-size: 28rpx;
  color: #666;
  height: 50rpx;
  line-height: 50rpx;
}

/* 日期网格 */
.date-grid {
  display: grid;
  grid-template-columns: repeat(7, 1fr);
  gap: 10rpx;
  width: 100%;
}

/* 日期项 */
.date-item {
  width: 100%;
  height: 100rpx;
  background-color: #fff;
  border-radius: 10rpx;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  box-shadow: 0 2rpx 4rpx rgba(0, 0, 0, 0.05);
  position: relative;
  transition: all 0.2s ease;
}

.date-item:active {
  transform: scale(0.96);
}

/* 当前月日期 */
.current-month {
  color: #333;
  cursor: pointer;
}

/* 非当前月日期 */
.other-month {
  color: #ccc;
  background-color: #f8f8f8;
  pointer-events: none;
}

/* 今天之前的日期 */
.before-today {
  color: #ccc;
  background-color: #f8f8f8;
  pointer-events: none;
}

/* 已标记日期 */
.marked {
  background-color: #e8f5e9;
}

.initial-marked {
  background-color: #e3f2fd !important;
}

.initial-marked .mark-dot {
  background-color: #1976d2;
}

.mark-dot {
  position: absolute;
  bottom: 10rpx;
  width: 12rpx;
  height: 12rpx;
  background-color: #4caf50;
  border-radius: 50%;
}

/* 周末样式 */
.date-item[weekday="0"] .date-number {
  color: #ff4444;
}

.date-item[weekday="6"] .date-number {
  color: #039be5;
}

.current-month.marked {
  background-color: #e8f5e9;
}

/* 滚动栏容器 */
.scroll-container {
  padding: 0;
}

/* 滚动栏分区 */
.scroll-section {
  margin-bottom: 30rpx;
}

/* 标题行（标题与箭头同行） */
.title-row {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 15rpx;
}

/* 标题样式 */
.scroll-title {
  font-size: 28rpx;
  font-weight: 500;
  color: #555;
  padding-left: 8rpx;
  border-left: 4rpx solid #4caf50;
  /* 绿色标题边框 */
}

.scroll-section:last-child .scroll-title {
  border-left-color: #1976d2;
}

/* 蓝色标题边框 */

/* 展开/收起箭头 */
.expand-icon {
  font-size: 32rpx;
  color: #666;
  width: 40rpx;
  height: 40rpx;
  display: flex;
  justify-content: center;
  align-items: center;
  cursor: pointer;
}

.scroll-section:first-child .expand-icon {
  font-weight: 600;
  color: #4caf50;
}

/* 绿色箭头 */
.scroll-section:last-child .expand-icon {
  font-weight: 600;
  color: #1976d2;
}

/* 蓝色箭头 */

/* 滚动视图 */
/* 滚动视图 - 水平排列 */
.scroll-view {
  white-space: nowrap;
  overflow-x: auto;
  overflow-y: hidden;
  padding-bottom: 10rpx;
}

/* 滚动项 - 外层水平排列，内部垂直排列 */
.scroll-item {
  display: inline-flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  width: 104rpx;
  height: 120rpx;
  border-radius: 12rpx;
  margin-right: 15rpx;
  text-align: center;
  box-shadow: 0 4rpx 10rpx rgba(0, 0, 0, 0.08);
  transition: all 0.2s ease;
  border: 1rpx solid #eee;
  padding: 0;
  background-clip: padding-box;
}

.scroll-item.marked {
  background-color: #e8f5e9;
  border-color: #dcedc8;
}

.scroll-item.initial-marked {
  background-color: #e3f2fd;
  border-color: #bbdefb;
}

.scroll-date {
  font-size: 28rpx;
  font-weight: 500;
  color: #333;
  margin-bottom: 6rpx;
  padding-top: 16rpx;
}

.scroll-week {
  font-size: 22rpx;
  color: #666;
  padding-bottom: 16rpx;
}

/* 展开容器 - 垂直排列 */
.expand-container {
  max-height: calc(2.5 * 120rpx);
  /* 两个半日期块高度 */
  overflow-y: auto;
  margin-top: 10rpx;
  padding-bottom: 10rpx;
}

/* 展开行 - 水平排列并允许换行 */
.expand-row {
  display: flex;
  flex-direction: row;
  flex-wrap: wrap;
  /* 关键修改：允许换行 */
  align-items: flex-start;
  margin-bottom: 0;
  width: 100%;
}

/* 展开项 - 保持内部垂直排列 */
.expand-item {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  width: 104rpx;
  /* 固定宽度 */
  height: 120rpx;
  border-radius: 12rpx;
  margin-right: 15rpx;
  /* 右侧间距 */
  margin-bottom: 15rpx;
  /* 底部间距 */
  text-align: center;
  box-shadow: 0 4rpx 10rpx rgba(0, 0, 0, 0.08);
  transition: all 0.2s ease;
  border: 1rpx solid #eee;
  padding: 0;
  background-clip: padding-box;
}

.expand-item.marked {
  background-color: #e8f5e9;
  border-color: #dcedc8;
}

.expand-item.initial-marked {
  background-color: #e3f2fd;
  border-color: #bbdefb;
}

.expand-date {
  font-size: 28rpx;
  font-weight: 500;
  color: #333;
  margin-bottom: 6rpx;
  padding-top: 16rpx;
}

.expand-week {
  font-size: 22rpx;
  color: #666;
  padding-bottom: 16rpx;
}

/* 优化滚动条样式 */
.expand-container::-webkit-scrollbar {
  width: 6rpx;
}

.expand-container::-webkit-scrollbar-thumb {
  background-color: #ddd;
  border-radius: 3rpx;
}

/* 定义旋转动画 - 展开状态 */
@keyframes rotateOpen {
  from {
    transform: rotate(0deg);
  }

  to {
    transform: rotate(90deg);
  }
}

/* 定义旋转动画 - 折叠状态 */
@keyframes rotateClose {
  from {
    transform: rotate(90deg);
  }

  to {
    transform: rotate(0deg);
  }
}

/* 展开状态（无fold类） */
.expand-icon .cuIcon-right:not(.fold) {
  animation: rotateOpen 0.3s ease forwards;
}

/* 折叠状态（有fold类） */
.expand-icon .cuIcon-right.fold {
  animation: rotateClose 0.3s ease forwards;
}

/* 确保图标初始状态正确 */
.expand-icon .cuIcon-right {
  display: inline-block;
  transition: transform 0.3s ease;
  transform-origin: center;
}

/* 状态栏占位 */
.status-bar {
  background-color: #1677FF;
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  z-index: 98;
}

/* 顶部导航栏样式 */
.top-nav-bar {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  height: 88rpx;
  display: flex;
  align-items: center;
  justify-content: center;
  background-color: #1677FF;
  z-index: 99;
}

.center-title {
  font-size: 36rpx;
  font-weight: 600;
  color: #FFFFFF;
}

/* 头部图标样式 */
.canui-head-box {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  height: 88rpx;
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 0 30rpx;
  z-index: 100;
  background-color: transparent;
  pointer-events: none;
}

.canui-head-box text {
  pointer-events: auto;
}

.cuIcon-back,
.cuIcon-home {
  font-size: 36rpx;
  color: #FFFFFF;
  cursor: pointer;
}

.cuIcon-back {
  padding: 10rpx;
}

.cuIcon-home {
  padding: 10rpx;
}

/* 主容器样式 */
.container {
  height: 100vh;
  background-color: #f8f9fa;
  display: flex;
  flex-direction: column;
  overflow: hidden;
}

/* 内容区域 */
.content-area {
  flex: 1;
  display: flex;
  flex-direction: column;
  overflow: hidden;
  position: relative;
}

/* 可滚动内容区域 - scroll-view 组件 */
.scrollable-content {
  /* scroll-view 组件本身就有滚动功能，不需要设置 overflow */
  /* 移除 overflow-y: auto，避免与 scroll-view 的滚动冲突 */
  height: 100%;
  /* iOS 兼容性：启用硬件加速，提升滚动性能，防止数据丢失 */
  -webkit-overflow-scrolling: touch;
  /* 使用 translateZ(0) 触发硬件加速，但不要设置 will-change 避免频繁重绘 */
  transform: translateZ(0);
  -webkit-transform: translateZ(0);
}

/* 固定在底部的区域 */
.fixed-bottom {
  position: fixed;
  bottom: 0;
  left: 0;
  right: 0;
  background-color: #f8f9fa;
  z-index: 10;
  padding: 20rpx;
  box-shadow: 0 -2rpx 10rpx rgba(0, 0, 0, 0.1);
}

/* 提示信息样式 */
.tip-notice {
  display: flex;
  align-items: center;
  padding: 20rpx 30rpx;
  margin-bottom: 20rpx;
  background-color: #fff7e6;
  border-left: 6rpx solid #faad14;
  border-radius: 8rpx;
}

.tip-icon {
  font-size: 32rpx;
  margin-right: 12rpx;
}

.tip-text {
  flex: 1;
  font-size: 26rpx;
  color: #874d00;
  line-height: 1.6;
}

/* 自定义日历样式 - 禁用日期显示为灰色 (#cacbcd) */
::v-deep .custom-calendar {

  /* 禁用日期样式 */
  .u-calendar__day--disabled {
    color: #cacbcd !important;
    background-color: #f5f5f5 !important;
    opacity: 1 !important;
    cursor: not-allowed !important;
    pointer-events: none !important;
  }

  /* 禁用日期的文本颜色 */
  .u-calendar__day--disabled .u-calendar__day__text,
  .u-calendar__day--disabled .u-calendar__day__number {
    color: #cacbcd !important;
  }

  /* 禁用日期的容器 */
  .u-calendar__day--disabled .u-calendar__day__inner {
    color: #cacbcd !important;
    background-color: #f5f5f5 !important;
  }
}

/* 如果 u-calendar 使用不同的类名，也需要添加 */
::v-deep .u-calendar {

  /* 禁用日期样式 - 多种可能的类名 */
  .u-calendar__day--disabled,
  .u-calendar-day--disabled,
  .disabled-day {
    color: #cacbcd !important;
    background-color: #f5f5f5 !important;
    opacity: 1 !important;
    cursor: not-allowed !important;
    pointer-events: none !important;
  }

  /* 禁用日期的文本元素 */
  .u-calendar__day--disabled .u-calendar__day__text,
  .u-calendar__day--disabled .u-calendar__day__number,
  .u-calendar__day--disabled view,
  .u-calendar__day--disabled text,
  .u-calendar-day--disabled .u-calendar__day__text,
  .u-calendar-day--disabled .u-calendar__day__number,
  .u-calendar-day--disabled view,
  .u-calendar-day--disabled text,
  .disabled-day view,
  .disabled-day text {
    color: #cacbcd !important;
  }

  /* 可选日期标记 - 仅对二类三类商家显示 */
  .type2-type3-calendar .u-calendar__day:not(.u-calendar__day--disabled):not(.u-calendar__day--selected) {
    position: relative;
  }

  /* 可选日期标记点 - 在日期下方添加绿色小点标记（仅二类三类商家） */
  .type2-type3-calendar .u-calendar__day:not(.u-calendar__day--disabled):not(.u-calendar__day--selected)::after {
    content: '';
    position: absolute;
    bottom: 4rpx;
    left: 50%;
    transform: translateX(-50%);
    width: 8rpx;
    height: 8rpx;
    background-color: #4caf50;
    border-radius: 50%;
    display: block;
  }

  /* 已选日期不显示标记点 */
  .type2-type3-calendar .u-calendar__day--selected::after {
    display: none !important;
  }
}

/* 模式切换按钮样式 */
.mode-switch {
  display: flex;
  gap: 20rpx;
  padding: 20rpx;
  background-color: #ffffff;
  margin-bottom: 20rpx;
  border-radius: 12rpx;
  box-shadow: 0 2rpx 8rpx rgba(0, 0, 0, 0.1);
}

.mode-btn {
  flex: 1;
  height: 80rpx;
  display: flex;
  align-items: center;
  justify-content: center;
  border-radius: 8rpx;
  background-color: #f5f5f5;
  transition: all 0.3s ease;
  
  text {
    font-size: 28rpx;
    color: #666;
  }
  
  &.active {
    background-color: #1677FF;
    
    text {
      color: #ffffff;
      font-weight: 600;
    }
  }
  
  &:active {
    transform: scale(0.98);
  }
}
</style>
